package com.time.admin.application.controller;

import com.google.common.base.Preconditions;
import com.time.admin.application.converter.CategoryDTOConverter;
import com.time.admin.application.dto.CategoryDTO;
import com.time.admin.common.entity.PageResult;
import com.time.admin.common.utils.CollectionUtils;
import com.time.admin.domain.entity.CategoryBO;
import com.time.admin.domain.service.AdminCategoryDomainService;
import com.time.auth.entity.Result;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.stream.Collectors;

/**
 * 分类管理控制层类
 *
 * @author: HuangQi
 * @date: Created in 14:41 2025/10/9
 * @description: 分类管理控制层
 */

@Slf4j
@RestController
@RequestMapping("/admin/category/")
public class CategoryController {

    @Autowired
    private AdminCategoryDomainService adminCategoryDomainService;


    /**
     * 新增分类
     *
     * @param categoryDTO 分类信息
     * @return 新增结果
     */
    @PostMapping("add")
    public Result<Boolean> add(@RequestBody CategoryDTO categoryDTO) {
        try {
            if (log.isInfoEnabled()) {
                log.info("Admin.CategoryController.add.dto:{}", categoryDTO);
            }
            // 参数校验
            Preconditions.checkNotNull(categoryDTO.getCategoryName(), "分类的名称不能为空");

            // 调用领域层
            CategoryBO categoryBO = CategoryDTOConverter.INSTANCE.convertDTOToBO(categoryDTO);
            Boolean addResult = adminCategoryDomainService.add(categoryBO);

            // 返回结果
            return Result.ok(addResult);
        } catch (Exception e) {
            // 异常处理
            log.error("Admin.CategoryController.add.error:{}", e.getMessage(), e);
            return Result.fail("管理模块新增分类失败");
        }
    }

    /**
     * 更新分类
     *
     * @param categoryDTO 更新分类信息
     * @return 更新结果
     */
    @PostMapping("update")
    public Result<Boolean> update(@RequestBody CategoryDTO categoryDTO) {
        try {
            if (log.isInfoEnabled()) {
                log.info("Admin.CategoryController.update.dto:{}", categoryDTO);
            }
            // 参数校验
            Preconditions.checkNotNull(categoryDTO.getCategoryId(), "分类的ID不能为空");
            Preconditions.checkNotNull(categoryDTO.getCategoryName(), "分类的名称不能为空");

            // 调用领域层
            CategoryBO categoryBO = CategoryDTOConverter.INSTANCE.convertDTOToBO(categoryDTO);
            Boolean updateResult = adminCategoryDomainService.update(categoryBO);

            // 返回结果
            return Result.ok(updateResult);
        } catch (Exception e) {
            // 异常处理
            log.error("Admin.CategoryController.update.error:{}", e.getMessage(), e);
            return Result.fail("管理模块更新分类失败");
        }
    }

    /**
     * 删除单条分类
     *
     * @param id 分类ID
     * @return 删除单条分类结果
     */
    @PostMapping("delete/{id}")
    public Result<Boolean> delete(@PathVariable("id") Long id) {
        try {
            if (log.isInfoEnabled()) {
                log.info("Admin.CategoryController.delete.id:{}", id);
            }
            // 参数校验
            Preconditions.checkNotNull(id, "分类的ID不能为空");

            // 调用领域层
            Boolean deleteResult = adminCategoryDomainService.delete(id);

            // 返回结果
            return Result.ok(deleteResult);
        } catch (Exception e) {
            // 异常处理
            log.error("Admin.CategoryController.delete.error:{}", e.getMessage(), e);
            return Result.fail("管理模块删除单条分类失败");
        }
    }

    /**
     * 删除多条分类
     *
     * @param ids 分类ID列表
     * @return 删除多条分类结果
     */
    @PostMapping("batchDelete")
    public Result<Boolean> batchDelete(@RequestBody List<Long> ids) {
        try {
            if (log.isInfoEnabled()) {
                log.info("Admin.CategoryController.batchDelete.ids:{}", ids.stream()
                        .map(String::valueOf)
                        .collect(Collectors.joining(",")));
            }
            // 参数校验
            Preconditions.checkArgument(!CollectionUtils.isEmpty(ids), "分类的ID列表不能为空");

            // 调用领域层
            Boolean deleteResult = adminCategoryDomainService.batchDelete(ids);

            // 返回结果
            return Result.ok(deleteResult);
        } catch (Exception e) {
            // 异常处理
            log.error("Admin.CategoryController.batchDelete.error:{}", e.getMessage(), e);
            return Result.fail("管理模块删除多条分类失败");
        }
    }

    /**
     * 获取全部顶级分类信息
     *
     * @return 顶级分类信息列表
     */
    @PostMapping("queryPrimaryCategory")
    public Result<List<CategoryDTO>> queryPrimaryCategory() {
        try {
            if (log.isInfoEnabled()) {
                log.info("Admin.CategoryController.batchDelete.queryPrimaryCategory");
            }

            // 调用领域层
            List<CategoryBO> categoryBOList = adminCategoryDomainService.queryPrimaryCategory();
            List<CategoryDTO> categoryDTOList = CategoryDTOConverter.INSTANCE.convertBOListToDTO(categoryBOList);

            // 返回结果
            return Result.ok(categoryDTOList);
        } catch (Exception e) {
            // 异常处理
            log.error("Admin.CategoryController.queryPrimaryCategory.error:{}", e.getMessage(), e);
            return Result.fail("管理模块获取全部顶级分类失败");
        }
    }


    /**
     * 获取指定分类的下级分类信息信息
     *
     * @param categoryDTO 父类分类信息
     * @return 下级分类信息列表
     */
    @PostMapping("queryCategoryByPrimary")
    public Result<List<CategoryDTO>> queryCategoryByPrimary(@RequestBody CategoryDTO categoryDTO) {
        try {
            if (log.isInfoEnabled()) {
                log.info("Admin.CategoryController.queryCategoryByPrimary.dto: {}", categoryDTO);
            }
            // 参数校验
            Preconditions.checkNotNull(categoryDTO.getCategoryId(), "分类的ID不能为空");

            // 调用领域层
            CategoryBO categoryBO = CategoryDTOConverter.INSTANCE.convertDTOToBO(categoryDTO);
            List<CategoryBO> categoryBOList = adminCategoryDomainService.queryCategoryByPrimary(categoryBO);
            List<CategoryDTO> categoryDTOList = CategoryDTOConverter.INSTANCE.convertBOListToDTO(categoryBOList);

            // 返回结果
            return Result.ok(categoryDTOList);
        } catch (Exception e) {
            // 异常处理
            log.error("Admin.CategoryController.queryPrimaryCategory.error:{}", e.getMessage(), e);
            return Result.fail("管理模块获取指定分类的下级分类失败");
        }
    }

    /**
     * 获取所有分类信息
     *
     * @param categoryDTO 查询条件
     * @return 所有分类信息列表
     */
    @PostMapping("queryAllCategory")
    public Result<PageResult<CategoryDTO>> queryAllCategory(@RequestBody CategoryDTO categoryDTO) {
        try {
            if (log.isInfoEnabled()) {
                log.info("Admin.CategoryController.queryAllCategory.dto: {}", categoryDTO);
            }

            // 调用领域层
            CategoryBO categoryBO = CategoryDTOConverter.INSTANCE.convertDTOToBO(categoryDTO);
            PageResult<CategoryBO> infoBOPageResult = adminCategoryDomainService.queryAllCategory(categoryBO);

            // 返回结果
            PageResult<CategoryDTO> infoDTOPageResult = CategoryDTOConverter.INSTANCE.convertBOPageToDTOPage(infoBOPageResult);
            return Result.ok(infoDTOPageResult);
        } catch (Exception e) {
            // 异常处理
            log.error("Admin.CategoryController.queryAllCategory.error:{}", e.getMessage(), e);
            return Result.fail("管理模块获取所有分类失败");
        }
    }

}
